package com.gdpu.project.dao.impl;

import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.gdpu.page.vo.QueryResult;
import com.gdpu.project.dao.NewsDao;
import com.gdpu.project.vo.CgProject;
import com.gdpu.project.vo.News;


public class NewsDaoImpl extends HibernateDaoSupport implements NewsDao {
	private static final Log log = LogFactory.getLog(NewsDaoImpl.class);
	// property constants
	public static final String NEWS_TYPE = "newsType";
	public static final String NEWS_TITLE = "newsTitle";
	public static final String NEWS_INFO = "newsInfo";
	public static final String CLICK_RATE = "clickRate";
	public static final String FBTIME ="fbTime";

	protected void initDao() {
		// do nothing
	}


	public void save(News transientInstance) {
		log.debug("saving News instance");
		try {
			getHibernateTemplate().save(transientInstance);
			log.debug("save successful");
		} catch (RuntimeException re) {
			log.error("save failed", re);
			throw re;
		}
	}

	public void delete(News persistentInstance) {
		log.debug("deleting News instance");
		try {
			getHibernateTemplate().delete(persistentInstance);
			log.debug("delete successful");
		} catch (RuntimeException re) {
			log.error("delete failed", re);
			throw re;
		}
	}

	public News findById(java.lang.Integer id) {
		log.debug("getting News instance with id: " + id);
		try {
			News instance = (News) getHibernateTemplate().get(
					"com.gdpu.project.vo.News", id);
			return instance;
		} catch (RuntimeException re) {
			log.error("get failed", re);
			throw re;
		}
	}

	public List<News> findByExample(News instance) {
		log.debug("finding News instance by example");
		try {
			List<News> results = getHibernateTemplate().findByExample(instance);
			log.debug("find by example successful, result size: "
					+ results.size());
			return results;
		} catch (RuntimeException re) {
			log.error("find by example failed", re);
			throw re;
		}
	}

	public List<News> findByProperty(String propertyName, Object value) {
		log.debug("finding News instance with property: " + propertyName
				+ ", value: " + value);
		try {
			String queryString = "from News as model where model."
					+ propertyName + "= ?";
			return getHibernateTemplate().find(queryString, value);
		} catch (RuntimeException re) {
			log.error("find by property name failed", re);
			throw re;
		}
	}


	public List<News> findByNewsType(Object newsType) {
		return findByProperty(NEWS_TYPE, newsType);
	}


	public List<News> findByNewsTitle(Object newsTitle) {
		return findByProperty(NEWS_TITLE, newsTitle);
	}

	public List<News> findByNewsInfo(Object newsInfo) {
		return findByProperty(NEWS_INFO, newsInfo);
	}


	public List<News> findByClickRate(Object clickRate) {
		return findByProperty(CLICK_RATE, clickRate);
	}

	public List<News> findAll() {
		log.debug("finding all News instances");
		try {
			String queryString = "from News";
			return getHibernateTemplate().find(queryString);
		} catch (RuntimeException re) {
			log.error("find all failed", re);
			throw re;
		}
	}
	public QueryResult<News> findAll(int firstindex,int maxresult) {
		log.debug("finding all News instances");
		try {
			QueryResult<News> queryResult=new QueryResult<News>();
			Query query=getSessionFactory().getCurrentSession().createQuery("from News news order by news.fbTime desc");
			if(firstindex!=-1&maxresult!=-1){
				query.setFirstResult(firstindex).setMaxResults(maxresult);
			}
			queryResult.setResultlist(query.list());
			query=getSessionFactory().getCurrentSession().createQuery("select count(*) from News news");
			queryResult.setTotalrecord((Long)query.uniqueResult());
			return queryResult;
		} catch (RuntimeException re) {
			log.error("find all failed", re);
			throw re;
		}
	}
	
	public News merge(News detachedInstance) {
		log.debug("merging News instance");
		try {
			News result = (News) getHibernateTemplate().merge(detachedInstance);
			log.debug("merge successful");
			return result;
		} catch (RuntimeException re) {
			log.error("merge failed", re);
			throw re;
		}
	}


	public void attachDirty(News instance) {
		log.debug("attaching dirty News instance");
		try {
			getHibernateTemplate().saveOrUpdate(instance);
			log.debug("attach successful");
		} catch (RuntimeException re) {
			log.error("attach failed", re);
			throw re;
		}
	}

	public void attachClean(News instance) {
		log.debug("attaching clean News instance");
		try {
			getHibernateTemplate().lock(instance, LockMode.NONE);
			log.debug("attach successful");
		} catch (RuntimeException re) {
			log.error("attach failed", re);
			throw re;
		}
	}
	
	@SuppressWarnings("unchecked")
	public List<News> findRecentNews() {
		log.debug("finding findRecentNews instances");
		try {
			DetachedCriteria criteria = DetachedCriteria.forClass(News.class);
			criteria.addOrder(Order.desc(FBTIME));
			getHibernateTemplate().setCacheQueries(true);
			return getHibernateTemplate().findByCriteria(criteria, 0, 6);
		} catch (RuntimeException re) {
			log.error("find findRecentNews failed", re);
			throw re;
		}
	}

	
	
	public static NewsDao getFromApplicationContext(ApplicationContext ctx) {
		return (NewsDao) ctx.getBean("NewsDAO");
	}


	@SuppressWarnings("unchecked")
	public List<News> splitPage(int startRow) {
		log.debug("finding pageNews News instances");
		try {
			DetachedCriteria criteria = DetachedCriteria.forClass(News.class);
			criteria.addOrder(Order.desc(FBTIME));
			return getHibernateTemplate()
					.findByCriteria(criteria, startRow, 10);
		} catch (RuntimeException re) {
			log.error("finding pageNews News failed", re);
			throw re;
		}
	}
}